import axios from 'axios';
import cacheService from './cacheService';

// 定义哪些API需要缓存以及缓存时间
const CACHE_CONFIG = {
  'GET /activity/daily': 60000, // 1分钟
  'GET /activity/report': 300000, // 5分钟
  'GET /contacts/recent': 120000, // 2分钟
  'GET /reports/user-dashboard': 300000, // 5分钟
};

// 根据环境智能选择API基础URL
const getBaseURL = () => {
  // 首先检查环境变量
  if (process.env.REACT_APP_API_URL) {
    return process.env.REACT_APP_API_URL;
  }
  
  // 根据当前部署环境选择合适的API URL
  const hostname = window.location.hostname;
  const protocol = window.location.protocol;
  
  if (hostname === 'localhost' || hostname === '127.0.0.1') {
    // 本地开发环境
    return 'http://localhost:3001/api';
  } else {
    // 生产环境，使用相同域名下的API路径
    return `${protocol}//${hostname}/api`;
  }
};

// 创建axios实例
const api = axios.create({
  baseURL: getBaseURL(),
  timeout: 300000, // 增加到300秒超时，与后端保持一致
  headers: {
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  }
});

// 重试配置
const MAX_RETRIES = 2;
const RETRY_DELAY = 1500;

// 封装重试逻辑
const retryRequest = async (config, error, retryCount = 0) => {
  // 达到最大重试次数，放弃重试
  if (retryCount >= MAX_RETRIES) {
    return Promise.reject(error);
  }
  
  // 计算延迟时间（可以使用指数退避策略）
  const delay = RETRY_DELAY * (retryCount + 1);
  
  console.log(`请求失败，${delay}ms后重试(${retryCount + 1}/${MAX_RETRIES}):`, config.url);
  
  // 延迟后重试
  return new Promise(resolve => setTimeout(resolve, delay))
    .then(() => api(config));
};

// 请求拦截器 - 添加token和缓存功能
api.interceptors.request.use(async (config) => {
  // 添加认证token
  const token = localStorage.getItem('token');
  if (token) {
    config.headers.Authorization = `Bearer ${token}`;
  }
  
  // 非GET请求不缓存
  if (config.method.toUpperCase() !== 'GET') {
    return config;
  }
  
  // 检查是否配置了缓存
  const cacheKey = `${config.method.toUpperCase()} ${config.url}`;
  const cacheTime = CACHE_CONFIG[cacheKey];
  
  if (!cacheTime) {
    return config;
  }
  
  // 生成缓存Key (包含参数)
  const paramKey = JSON.stringify(config.params || {});
  const fullCacheKey = `${cacheKey}:${paramKey}`;
  
  // 尝试从缓存获取
  const cacheData = cacheService.getCache(fullCacheKey);
  
  if (cacheData) {
    console.log(`[缓存] 使用缓存数据: ${cacheKey}`);
    
    // 创建一个假的Promise来直接返回缓存结果
    return {
      ...config,
      adapter: () => {
        return Promise.resolve({
          data: cacheData,
          status: 200,
          statusText: 'OK',
          headers: {},
          config,
          request: {}
        });
      }
    };
  }
  
  return config;
}, (error) => Promise.reject(error));

// 添加请求重试功能
const retryInterceptor = (err) => {
  const config = err.config;
  
  // 如果未设置重试配置或已达到最大重试次数，则拒绝
  if (!config || !config.retry || config.retryCount >= config.retry) {
    return Promise.reject(err);
  }
  
  // 设置重试计数
  config.retryCount = config.retryCount || 0;
  config.retryCount += 1;
  
  // 创建新的Promise等待重试
  const retryDelay = config.retryDelay || 1000;
  const backoffFactor = Math.pow(2, config.retryCount) * retryDelay;
  
  return new Promise(resolve => {
    setTimeout(() => {
      console.log(`重试请求 (${config.retryCount}/${config.retry}): ${config.url}`);
      resolve(api(config));
    }, backoffFactor);
  });
};

// 响应拦截器 - 添加缓存和重试
api.interceptors.response.use((response) => {
  // 检查是否需要缓存
  const cacheKey = `${response.config.method.toUpperCase()} ${response.config.url}`;
  const cacheTime = CACHE_CONFIG[cacheKey];
  
  if (cacheTime && response.status === 200) {
    const paramKey = JSON.stringify(response.config.params || {});
    const fullCacheKey = `${cacheKey}:${paramKey}`;
    cacheService.setCache(fullCacheKey, response.data, cacheTime);
    console.log(`[缓存] 数据已缓存: ${cacheKey}`);
  }
  
  return response;
}, (error) => {
  // 检查是否是网络错误或超时
  if (!error.response && (error.code === 'ECONNABORTED' || error.message.includes('Network Error'))) {
    console.log('检测到网络错误，尝试重试');
    // 设置重试配置
    error.config.retry = 3; // 重试3次
    error.config.retryDelay = 1000; // 基础延迟1秒
    return retryInterceptor(error);
  }
  
  return Promise.reject(error);
});

// 定期清理过期缓存
setInterval(cacheService.cleanExpiredCache, 60000); // 每分钟清理一次

export default api; 